home *** CD-ROM | disk | FTP | other *** search
/ Collection of Tools & Utilities / Collection of Tools and Utilities.iso / c / recio202.zip / rget.c < prev    next >
C/C++ Source or Header  |  1994-05-05  |  21KB  |  564 lines
  1. /*****************************************************************************
  2.    MODULE: rget.c
  3.   PURPOSE: recio input functions
  4. COPYRIGHT: (C) 1994 William Pierpoint
  5.  COMPILER: Borland C Version 3.1
  6.        OS: MSDOS Version 6.2
  7.   VERSION: 2.02
  8.   RELEASE: May 5, 1994
  9. *****************************************************************************/
  10.  
  11. #include <ctype.h>
  12. #include <errno.h>
  13. #include <stdio.h>
  14. #include <stdlib.h>
  15. #include <string.h>
  16.  
  17. #include "recio.h"
  18.  
  19. extern int _rstatus(REC *rp, int mode);
  20. extern int _rismode(REC *rp, int mode);
  21. extern void _rsetexitfn(REC *rp);
  22.  
  23. /* private macros */
  24. #define RECBUFSIZ_MIN 2         /* min one character and new line */
  25. #define FLDBUFSIZ_MIN 1         /* min one character */
  26.  
  27. #define RECBUFSIZE    max(RECBUFSIZ, RECBUFSIZ_MIN)
  28. #define FLDBUFSIZE    max(FLDBUFSIZ, FLDBUFSIZ_MIN)
  29.  
  30. #define rcol(rp)         ((rp)->r_colno)
  31. #define rflags(rp)       ((rp)->r_flags)
  32. #define rfd(rp)          ((rp)->r_fd)
  33. #define rfp(rp)          ((rp)->r_fp)
  34. #define rreclen(rp)      ((rp)->r_reclen)
  35. #define rrecsiz(rp)      ((rp)->r_recsiz)
  36. #define rfldsiz(rp)      ((rp)->r_fldsiz)
  37. #define rfldch(rp)       ((rp)->r_fldch)
  38. #define rtxtch(rp)       ((rp)->r_txtch)
  39.  
  40. /****************************************************************************/
  41. static int                   /* return error number (0=no error)            */
  42.     _rsetfldsiz(             /* set field buffer size                       */
  43.         REC   *rp,           /* record pointer                              */
  44.         size_t fldsiz)       /* field buffer size                           */
  45. /****************************************************************************/
  46. {
  47.     int errnum=0;            /* error number */
  48.     char *fldp;              /* pointer to new field buffer */
  49.  
  50.     /* if no memory allocated to field buffer */
  51.     if (!rflds(rp)) {
  52.  
  53.         /* determine minimum size of field buffer */
  54.         fldsiz = max(fldsiz, FLDBUFSIZE);
  55.  
  56.         /* initially allocate memory for field buffer */
  57.         do {
  58.             fldp = (char *) calloc(fldsiz+1, sizeof(char));
  59.             if (!fldp) {
  60.                 errnum = rseterr(rp, R_ENOMEM);
  61.                 if (errnum) goto done;
  62.             }
  63.         } while (!fldp);
  64.         rflds(rp) = fldp;
  65.         rfldsiz(rp) = fldsiz;
  66.         _rsetexitfn(rp);
  67.  
  68.     /* if field buffer needs to be larger */
  69.     } else if (fldsiz > rfldsiz(rp)) {
  70.  
  71.         /* reallocate memory for field buffer */
  72.         do {
  73.             fldp = (char *) realloc(rflds(rp), fldsiz+1);
  74.             if (!fldp) {
  75.                 errnum = rseterr(rp, R_ENOMEM);
  76.                 if (errnum) goto done;
  77.             }
  78.         } while (!fldp);
  79.         rflds(rp) = fldp;
  80.         rfldsiz(rp) = fldsiz;
  81.     }
  82.  
  83. done:
  84.     return (errnum);
  85. }
  86.  
  87. /****************************************************************************/
  88. static int                   /* return error number (0=no error)            */
  89.     _rsetrecsiz(             /* set record buffer size                      */
  90.         REC   *rp,           /* record pointer                              */
  91.         size_t recsiz)       /* record buffer size                          */
  92. /****************************************************************************/
  93. {
  94.     int errnum=0;            /* error number */
  95.     char *recp;              /* pointer to new record buffer */
  96.  
  97.     /* if no memory allocated to field buffer */
  98.     if (!rrecs(rp)) {
  99.  
  100.         /* determine minimum size of record buffer */
  101.         recsiz = max(recsiz, RECBUFSIZE);
  102.  
  103.         /* initially allocate memory for record buffer */
  104.         do {
  105.             recp = (char *) calloc(recsiz+1, sizeof(char));
  106.             if (!recp) {
  107.                 errnum = rseterr(rp, R_ENOMEM);
  108.                 if (errnum) goto done;
  109.             }
  110.         } while (!recp);
  111.         rrecs(rp) = recp;
  112.         rrecsiz(rp) = recsiz;
  113.         _rsetexitfn(rp);
  114.  
  115.     /* if record buffer needs to be larger */
  116.     } else if (recsiz > rrecsiz(rp)) {
  117.  
  118.         /* reallocate memory for record buffer */
  119.         do {
  120.             recp = (char *) realloc(rrecs(rp), recsiz+1);
  121.             if (!recp) {
  122.                 errnum = rseterr(rp, R_ENOMEM);
  123.                 if (errnum) goto done;
  124.             }
  125.         } while (!recp);
  126.         rrecs(rp) = recp;
  127.         rrecsiz(rp) = recsiz;
  128.     }
  129.  
  130. done:
  131.     return (errnum);
  132. }
  133.  
  134. /****************************************************************************/
  135. static int                   /* return !0 on match                          */
  136.     isfldch(                 /* is character the field separator character? */
  137.         REC *rp,             /* record pointer                              */
  138.         int  ch)             /* character to test                           */
  139. /****************************************************************************/
  140. {
  141.     int ismatch=0;           /* return 0 if no match */
  142.  
  143.     if (isascii(ch)) { 
  144.         if (rfldch(rp) == ' ') {
  145.             ismatch = isspace(ch);
  146.         } else {
  147.             ismatch = (!(ch - rfldch(rp)));
  148.         }
  149.     }
  150.     return (ismatch);
  151. }
  152.  
  153. /****************************************************************************/
  154. static int                   /* return !0 on match                          */
  155.     istxtch(                 /* is character the text delimiter character?  */
  156.         REC *rp,             /* record pointer                              */
  157.         int  ch)             /* character to test                           */
  158. /****************************************************************************/
  159. {
  160.     int ismatch=0;           /* return 0 if no match */
  161.  
  162.     if (isascii(ch)) { 
  163.         if (rtxtch(rp) == ' ') {
  164.             ismatch = isspace(ch);
  165.         } else {
  166.             ismatch = (!(ch - rtxtch(rp)));
  167.         }
  168.     }
  169.     return (ismatch);
  170. }
  171.  
  172. /****************************************************************************/
  173. static size_t                /* return length of field                      */
  174.     _rfldlen(                /* get length of field                         */
  175.         REC *rp)             /* record pointer                              */
  176. /****************************************************************************/
  177. {
  178.     size_t len=0;            /* length of field (0=missing field)*/
  179.     size_t col;              /* column location */
  180.     int ch;                  /* character at column location */
  181.     int qstate=0;            /* quoted string state (0=off; 1=on) */
  182.  
  183.     /* get column location for first non-whitespace character in field */
  184.     for (col=rcol(rp); col < rreclen(rp); col++) {
  185.         if (!isspace(rrecs(rp)[col])) break;
  186.     }
  187.  
  188.     /* find field separator at end of field */
  189.     if (istxtch(rp, ' ')) {
  190.         for (; col < rreclen(rp); col++) {
  191.             ch = rrecs(rp)[col];
  192.             if (isfldch(rp, ch)) break;
  193.         }
  194.     } else {
  195.         for (; col < rreclen(rp); col++) {
  196.             ch = rrecs(rp)[col];
  197.             /* don't search for fldch between txtch's */
  198.             if (istxtch(rp, ch)) qstate = !qstate;
  199.             if (!qstate && isfldch(rp, ch)) break;
  200.         }
  201.     }
  202.  
  203.     /* get length of field */
  204.     if (rcol(rp) < rreclen(rp)) {
  205.         len = col - rcol(rp) + 1;
  206.     }
  207.  
  208.     return (len);
  209. }
  210.  
  211. /****************************************************************************/
  212. static int                   /* return error state (0=no error)             */
  213.     _rskipfld(               /* skip to the next field                      */
  214.         REC   *rp,           /* record pointer                              */
  215.         size_t len)          /* length of field if known, 0 if unknown      */
  216. /****************************************************************************/
  217. {
  218.     int err=0;          /* error state (0=no error; EOF=past end-of-record) */
  219.  
  220.     /* if length of field is unknown */
  221.     if (!len) {
  222.         /* determine length */
  223.         len=_rfldlen(rp);
  224.     }
  225.     
  226.     /* if not at end of record */
  227.     if (rcol(rp) <= rreclen(rp)) {
  228.